Sentinel-Probe

Web Security Scanner — Pour développeurs, freelances & pentesters

Sentinel-Probe est un outil d'audit de sécurité web asynchrone conçu pour analyser rapidement une cible et identifier les vulnérabilités les plus courantes. Il dispose d'un moteur de templates YAML permettant d'écrire des checks custom sans modifier le code Python.

⚠️ Avertissement légal — Utilisation autorisée uniquement

Sentinel-Probe est un outil d'audit de sécurité conçu exclusivement pour des tests sur des systèmes que vous possédez ou pour lesquels vous disposez d'une autorisation écrite explicite.

L'utilisation de cet outil sans autorisation préalable sur des systèmes tiers est illégale dans la plupart des pays :

France : article 323-1 du Code pénal — accès frauduleux à un système informatique — jusqu'à 3 ans d'emprisonnement et 100 000 € d'amende
Union européenne : Directive 2013/40/UE relative aux attaques contre les systèmes d'information
International : lois équivalentes applicables dans la quasi-totalité des juridictions

Cas d'usage légitimes :

Tests de pénétration sur vos propres applications web
Audits de sécurité mandatés par contrat signé (pentest)
Programmes de bug bounty sur les périmètres autorisés
Environnements de lab / CTF dédiés aux tests

L'auteur de Sentinel-Probe décline toute responsabilité pour tout usage contraire à la loi ou aux présentes conditions. Toute utilisation malveillante ou non autorisée est à la seule et entière responsabilité de l'utilisateur.

En téléchargeant ou en utilisant ce logiciel, vous acceptez de n'en faire usage que dans le cadre de la loi applicable et avec les autorisations requises.

Fonctionnalités

Module	Flag	Description
Template Engine	`--templates`	Moteur YAML — 9 800+ templates communautaires (CVE, exposure, misconfig, injection) + templates custom. Protocoles : HTTP, DNS, TCP, WebSocket, FTP, SMTP, IMAP, LDAP
IDOR Scanner	`--idor`	Insecure Direct Object Reference — IDs numériques ±1 et UUID alternés, confirmation 2× (confidence scoring)
XXE Scanner	`--xxe`	XML External Entity Injection — 5 payloads (fichiers locaux, SSRF IMDS, PHP wrappers), upload multipart, 3 niveaux de détection
JWT Scanner	`--jwt`	Vulnérabilités JWT : alg:none (4 variantes), brute-force secret HMAC, expired token, kid injection, payload analysis
SSRF Scanner	`--ssrf`	Server-Side Request Forgery — 30 paramètres suspects, 14 cibles (IMDS AWS/GCP/Azure, loopback, bypass encodings), endpoints sondés
CRLF Scanner (v1.1.3)	`--crlf`	HTTP Header Injection via séquences CRLF — 9 variantes (raw, URL-encodées, Unicode-smuggling), détection primaire header + secondaire corps
GraphQL Scanner (v1.1.3)	`--graphql`	Découverte automatique d'endpoints, introspection activée, field suggestions, injection dans les arguments, batching non limité
WAF Detection	(auto)	Détection automatique (14 signatures + cookies) + bypass payloads : double-URL, unicode, comment inject, null byte
OpenAPI Import	`--openapi`	Import spec OpenAPI 3.x / Swagger 2.0 → couverture complète de tous les endpoints pour tous les scanners
Scope Filter	`--include-path` `--exclude-path` `--include-param` `--exclude-param`	Filtrage regex sur les chemins et paramètres testés
Browser Engine	`--browser`	Scanner JS-rendered avec Playwright — DOM XSS, secrets dans JS, mixed content, endpoints XHR/fetch
Headers Audit	`--headers`	CSP, HSTS, X-Frame-Options, CORS, info disclosure
SSL/TLS Audit	`--ssl`	Protocoles, certificat, expiration
CORS Check	`--cors`	Misconfiguration CORS (wildcard, credentials, bypass)
SQL Injection	`--sqli`	Error-based, boolean-differential et time-based blind (MySQL, MSSQL, PostgreSQL, SQLite)
NoSQL Injection	`--nosqli`	GET array-notation ($ne/$gt/$regex/$exists) + JSON POST, bypass auth, signatures MongoDB
XSS Scanner	`--xss`	Reflected (HTML), DOM-context (JS break-out, AngularJS, polyglot) et Stored XSS
SSTI Scanner	`--ssti`	Server-Side Template Injection — 9 moteurs (Jinja2, Twig, Freemarker, Velocity, Smarty, Mako, Handlebars, ERB, Tornado)
LFI / Path Traversal	`--lfi`	16 payloads (classiques, encodés, null-byte, wrappers PHP, Windows) + confirmation par signatures
Open Redirect	`--redir`	13 variantes de payloads, endpoints communs (`/login`, `/logout`…), inspection header `Location`
Command Injection	`--cmdi`	Output-reflection (canary, `whoami`, `id`) + time-based blind (`sleep 4`) — Unix & Windows
Dir Enumeration	`--dirs`	Enumération de chemins via wordlist (400+ entrées)
Port Scanner	`--ports`	Ports courants (21, 22, 80, 443, 3306, 8080…) + banner grabbing (SSH, FTP, Redis, MySQL…)
Vulnerability Scanner	`--vuln`	20 modules : CRLF, Clickjacking, SSRF, XXE, GraphQL, JWT, HTTP Smuggling…
Stress Test	`--stress`	Test de charge asynchrone avec stats temps réel (RPS, P95, P99)
Subdomain Takeover	`--takeover`	Détection de sous-domaines non revendiqués (35 services)
Dependency Confusion	`--dep`	Manifestes exposés + paquets npm/PyPI non publiés
Tech Stack Detection	(toujours actif)	Fingerprinting passif — headers, cookies, 16 path probes (`.env`, `.git`, phpinfo…)
Crawler BFS	`--crawl`	Découverte automatique d'URLs et formulaires, alimente tous les scanners actifs

Installation

git clone https://github.com/Lydiaix-Code/Sentinel-Probe.git
cd Sentinel-Probe
pip install -r requirements.txt

Recommandé : installer certifi pour éviter les erreurs SSL sur macOS/Windows
pip install certifi

Utilisation

# Scan complet (tous les modules + templates)
python3 main.py -t https://monsite.com --all -y

# Scan avec détection OOB (SSRF, Log4Shell, blind CMDi)
python3 main.py -t https://monsite.com --templates --oob -y

# Valider les templates YAML (CI/CD pre-commit)
python3 main.py --validate-templates
python3 main.py --validate-templates --templates-dir ./mes-templates/

# Scan complet avec tous les exports
python3 main.py -t https://monsite.com --all --md -o rapport.html --json rapport.json -y

# Profils prédéfinis
python3 main.py -t https://monsite.com --profile quick    # passif uniquement
python3 main.py -t https://monsite.com --profile standard # commun + crawl 30 pages
python3 main.py -t https://monsite.com --profile thorough # tout + crawl 100 pages

# Modules individuels
python3 main.py -t https://monsite.com --headers --ssl --cors
python3 main.py -t https://monsite.com --sqli --xss --nosqli
python3 main.py -t https://monsite.com --ssti --lfi --cmdi --redir
python3 main.py -t https://monsite.com --xxe --ssrf --jwt --token "eyJ..."
python3 main.py -t https://monsite.com --crlf --graphql          # v1.1.3
python3 main.py -t https://monsite.com --takeover --dep

# Filtrer par niveau de confiance (v1.1.3)
python3 main.py -t https://monsite.com --sqli --xss --min-confidence firm     # masque tentative
python3 main.py -t https://monsite.com --all  --min-confidence certain        # uniquement certains
python3 main.py -t https://monsite.com --stress --threads 30 --duration 60

# Template engine
python3 main.py -t https://monsite.com --templates                                   # tous les templates
python3 main.py -t https://monsite.com --templates --templates-tags cve,exposure      # filtre par tags
python3 main.py -t https://monsite.com --templates --templates-severity critical,high  # filtre par sévérité
python3 main.py -t https://monsite.com --templates --templates-id env-file-exposure   # template spécifique
python3 main.py -t https://monsite.com --templates --templates-dir ./mes-templates/   # répertoire custom

# Avec crawler BFS (alimente tous les scanners actifs)
python3 main.py -t https://monsite.com --crawl --sqli --xss --ssti --lfi --cmdi -y

# Multi-cibles depuis un fichier
python3 main.py --targets urls.txt --all -y

# Limiter le débit global (req/s par module actif)
python3 main.py -t https://monsite.com --all --rate-limit 20 -y

# Avec proxy (Burp Suite, OWASP ZAP)
python3 main.py -t https://monsite.com --all --proxy http://127.0.0.1:8080 -y

# Avec authentification (cookie ou Bearer token)
python3 main.py -t https://monsite.com --all --cookie "session=abc123" -y
python3 main.py -t https://monsite.com --vuln --token "eyJhbGciOiJIUzI1NiJ9..." -y

# Mode sécurisé — désactive les payloads actifs (SQLi, XSS, SSTI, CMDi, LFI, stress…)
python3 main.py -t https://monsite.com --all --safe -y

# CI/CD — exit code 2 si vulnérabilité HIGH/CRITICAL
python3 main.py -t https://monsite.com --all --exit-code -y

# Comparer deux rapports JSON (régressions)
python3 main.py --diff rapport_v1.json rapport_v2.json

# Depuis un fichier de configuration YAML
python3 main.py -c scan.yaml

Moteur de templates YAML

Le moteur de templates permet d'écrire des checks de sécurité en YAML sans modifier le code Python.

Format d'un template

id: env-file-exposure
info:
  name: Environment File Exposure (.env)
  severity: critical        # critical | high | medium | low | info
  tags: [exposure, config]
  description: Détecte les fichiers .env exposés.
  reference:
    - https://owasp.org/www-project-top-ten/

http:
  - method: GET
    path:
      - "{{BaseURL}}/.env"
      - "{{BaseURL}}/.env.local"
    redirects: false

    matchers-condition: and   # and | or
    matchers:
      - type: status
        status: [200]
      - type: word
        words: ["DB_PASSWORD", "APP_KEY", "SECRET_KEY"]
        condition: or
        part: body            # body | header | all | <nom-header>
        case-insensitive: true

    extractors:
      - type: regex
        name: db_password
        regex: ["DB_PASSWORD=(.+)"]
        group: 1
        part: body

Variables disponibles

Variable	Valeur
`{{BaseURL}}`	`https://monsite.com`
`{{Host}}`	`monsite.com:443`
`{{Hostname}}`	`monsite.com`
`{{Scheme}}`	`https`
`{{Port}}`	`443`
`{{Path}}`	`/chemin/actuel`
`{{File}}`	`index.php`
`{{randstr}}` / `{{randstr(12)}}`	chaîne aléatoire fraîche par requête
`{{rand_int(1000,9999)}}`	entier aléatoire
`{{unix_time}}`	timestamp Unix courant
`{{interactsh-url}}`	URL OOB (avec `--oob` actif)

Types de matchers

Type	Paramètres clés
`word`	`words`, `condition: and\|or`, `part`, `case-insensitive`, `negative`
`regex`	`regex`, `condition`, `part`
`status`	`status: [200, 301, ...]`
`size`	`size: 1000`, `comparison: >\|<\|==\|>=\|<=`
`dsl`	`dsl: ["status_code == 200 && contains(body, 'admin')"]`
`binary`	`binary: ["hex_string"]`

Types d'extracteurs

Type	Description
`regex`	Expression régulière avec groupe de capture (`group: 1`)
`kval`	Valeur de header ou cookie
`json`	Chemin dot-notation dans un JSON (`json: ["data.token"]`)
`dsl`	Expression DSL arbitraire
`xpath`	Expression XPath 1.0 sur HTML/XML (`attribute` optionnel)

DSL — 35+ fonctions disponibles

# Prédicats
contains(s, sub)   starts_with(s, prefix)   ends_with(s, suffix)   regex(pattern, s)

# Transformations string
lower(s)   upper(s)   trim(s)   reverse(s)   replace(s, old, new)
split(s, sep)   join(sep, list)   concat(a, b, ...)

# Numérique
len(s)   count(s, sub)   to_number(s)   int(x)   abs(x)

# Encodage / hash
base64(s)   base64_decode(s)   url_encode(s)   url_decode(s)
hex_encode(s)   hex_decode(s)   md5(s)   sha1(s)   sha256(s)

# Aléatoire / temps
randstr(n)   rand_base(n)   rand_int(lo, hi)   unix_time()   date_time(fmt)

# Compression
gzip(s)   zlib_inflate(s)

Variables DSL : status_code, body, headers, content_length, content_type, response_time

9 800+ templates communautaires

Les templates sont organisés par catégorie dans templates/community/ :

Catégorie	Exemples
cves/	CVE-2021-44228 (Log4Shell), CVE-2021-41773 (Apache), CVE-2021-3129 (Laravel)…
exposures/	`.env`, `.git`, phpinfo, Swagger, GraphQL, AWS IMDS, Kubernetes…
misconfiguration/	CORS, Clickjacking, Directory listing, méthodes TRACE/PUT…
vulnerabilities/	SQLi, XSS, SSTI, Open Redirect, SSRF…
technologies/	Fingerprinting : WordPress, Laravel, Spring Boot, Django…
default-logins/	Credentials par défaut sur panneaux admin

# Mettre à jour les templates (depuis ProjectDiscovery)
python3 main.py --update

# Scanner avec les templates communautaires
python3 main.py -t https://monsite.com --templates --templates-dir templates/community/

# Filtrer par sévérité
python3 main.py -t https://monsite.com --templates --templates-dir templates/community/ --templates-severity critical,high

Écrire un template custom

# Créer templates/custom/mon-check.yaml
# Lancer uniquement les templates du répertoire custom
python3 main.py -t https://monsite.com --templates --templates-dir templates/custom/

# Ou filtrer par tag
python3 main.py -t https://monsite.com --templates --templates-tags mon-tag

Options

Option	Description	Défaut
`-t`, `--target`	URL cible	—
`--targets FILE`	Fichier texte avec une URL par ligne (multi-cibles)	—
`--profile`	Profil prédéfini : `quick` / `standard` / `thorough`	—
`-c`, `--config`	Fichier YAML de configuration (les options CLI ont priorité)	—
`--all`	Lancer tous les modules (inclut `--templates`)	—
`--headers`	Audit des en-têtes HTTP	—
`--ssl`	Audit SSL/TLS	—
`--cors`	Check CORS	—
`--sqli`	Scanner SQLi	—
`--nosqli`	Scanner NoSQL Injection (MongoDB)	—
`--xss`	Scanner XSS	—
`--ssti`	Scanner SSTI	—
`--lfi`	Scanner LFI / Path Traversal	—
`--redir`	Scanner Open Redirect	—
`--cmdi`	Scanner Command Injection	—
`--crlf`	Scanner CRLF / HTTP Header Injection (v1.1.3)	—
`--graphql`	Scanner GraphQL (introspection, injection, batching) (v1.1.3)	—
`--dirs`	Énumération de répertoires	—
`--ports`	Scan de ports	—
`--stress`	Test de charge	—
`--vuln`	Scanner de vulnérabilités (20 modules)	—
`--takeover`	Détection subdomain takeover	—
`--dep`	Détection dependency confusion	—
`--templates`	Moteur de templates YAML	—
`--templates-dir DIR`	Répertoire de templates (défaut : `templates/`)	—
`--templates-tags TAGS`	Filtrer par tags séparés par virgule	—
`--templates-severity SEV`	Filtrer par sévérité (`critical,high`…)	—
`--templates-id IDS`	Lancer uniquement ces template IDs	—
`--oob`	Activer la détection OOB via interact.sh (SSRF, Log4Shell, blind CMDi)	—
`--http2`	Backend httpx HTTP/2 pour le moteur de templates (nécessite `httpx[http2]`)	—
`--browser`	Scanner JS-rendered avec Playwright (DOM XSS, secrets, mixed content)	—
`--auth-config FILE`	Fichier JSON d'auth avancée (OAuth2 CC/PKCE, form login, NTLM)	—
`--plugins`	Charger et exécuter les plugins externes (`sentinel_probe.modules`)	—
`--list-plugins`	Lister les plugins disponibles sans scanner	—
`--validate-templates`	Valider les templates YAML sans scanner (exit 1 si invalide)	—
`--crawl`	Crawler BFS (alimente les scanners actifs)	—
`--crawl-depth N`	Nombre max de pages crawlées	`50`
`--threads N`	Threads simultanés (stress test)	`20`
`--duration SEC`	Durée du stress test (secondes)	`30`
`--rps N`	Limite req/s stress test — `0` = illimité	`0`
`--rate-limit N`	Limite globale req/s par module actif	`0`
`--timeout SEC`	Timeout par requête (secondes)	`10`
`--proxy URL`	Proxy HTTP/HTTPS (Burp Suite, ZAP)	—
`--safe`	Mode sécurisé : désactive les payloads actifs	—
`--cookie VALUE`	Cookie d'authentification	—
`--token TOKEN`	Bearer token (`Authorization: Bearer …`)	—
`--user USER:PASS`	Authentification Basic HTTP	—
`--har FILE`	Importer les requêtes d'un fichier HAR (Burp Suite / DevTools)	—
`--resume`	Reprendre un scan interrompu (`.sentinel_resume.json`)	—
`-o`, `--output FILE`	Export du rapport HTML	—
`--json FILE`	Export du rapport JSON	—
`--sarif FILE`	Export SARIF 2.1.0 (GitHub Code Scanning / GitLab Security)	—
`--md`	Export du rapport Markdown dans `reports/`	—
`--diff OLD NEW`	Comparer deux rapports JSON	—
`--min-confidence`	Niveau de confiance minimum : `tentative` / `firm` / `certain` (v1.1.3)	`tentative`
`--exit-code`	Exit code 2 si vulnérabilité HIGH/CRITICAL (CI/CD)	—
`-y`, `--yes`	Confirmer sans prompt interactif	—

Nouveautés v1.1.3

CRLF / Header Injection Scanner (`--crlf`)

python3 main.py -t https://target.com --crlf
python3 main.py -t https://target.com --crawl --crlf

Détecte l'injection de séquences \r\n dans les en-têtes HTTP de réponse — vecteur de response splitting, cache poisoning et XSS via header.

Séquence	Encodage
`\r\n`	Raw
`%0d%0a` / `%0D%0A`	URL double-encodé
`%0d` / `%0a`	CR ou LF seul
`%E5%98%8D%E5%98%8A`	Unicode-smuggling (UTF-8)

Détection primaire : l'en-tête X-CRLF-Sentinel injecté apparaît dans les headers de réponse → high
Détection secondaire : valeur injectée non encodée dans le corps → medium

GraphQL Scanner (`--graphql`)

python3 main.py -t https://target.com --graphql
python3 main.py -t https://target.com --crawl --graphql

Audit complet de la sécurité GraphQL en 4 étapes :

Check	Sévérité	Description
Introspection activée	medium	Schéma complet exposé — cartographie API totale possible
Field suggestions	low	"Did you mean …" expose partiellement le schéma sans introspection
Injection dans les arguments	high	SQLi / NoSQLi dans les champs — erreur resolver exposée
Batching non limité	medium	10 requêtes en batch acceptées — risque DoS / brute-force

Endpoints auto-découverts : /graphql, /api/graphql, /v1/graphql, /query, /gql…

Flag `--min-confidence` (réduction des faux positifs)

python3 main.py -t https://target.com --sqli --xss --min-confidence firm

Filtre global appliqué avant le rapport sur les findings probabilistes (time-based blind, boolean-differential, IDOR) :

Valeur	Effet
`tentative` (défaut)	Affiche tout
`firm`	Masque les findings `tentative` (1/3 hits)
`certain`	Masque `tentative` + `firm` — uniquement 3/3 confirmés

Browser Engine — Playwright (`--browser`)

pip install playwright && playwright install chromium
python3 main.py -t https://target.com --browser -y

Scanne les pages JavaScript-rendues invisibles aux scanners HTTP-only :

Check	Description
DOM XSS sinks	`eval()`, `innerHTML`, `document.write`, `location.href`, `new Function()`…
Secrets dans JS	API keys, JWT tokens, AWS keys, passwords dans le code client
Clickjacking	Absence de `X-Frame-Options` / `CSP frame-ancestors` (rendu navigateur)
Mixed content	Ressources HTTP chargées depuis une page HTTPS
Endpoints API	Appels XHR/fetch capturés au runtime (endpoints dynamiques invisibles au crawl HTML)
Console leaks	Messages d'erreur contenant des mots-clés sensibles (`token`, `password`, `secret`…)

Auth avancée (`--auth-config`)

python3 main.py -t https://api.target.com --all --auth-config auth.json -y

Fichier auth.json — 4 types supportés :

OAuth2 Client Credentials :

{
  "type": "oauth2_cc",
  "token_url": "https://auth.example.com/oauth/token",
  "client_id": "my-client",
  "client_secret": "my-secret",
  "scope": "read:api"
}

Multi-step form login (auto-CSRF) :

{
  "type": "form",
  "login_url": "https://target.com/login",
  "username": "admin",
  "password": "secret",
  "success_check": "dashboard"
}

OAuth2 PKCE :

{
  "type": "oauth2_pkce",
  "auth_url": "https://auth.example.com/authorize",
  "token_url": "https://auth.example.com/oauth/token",
  "client_id": "my-spa-client"
}

NTLM (Active Directory) :

{
  "type": "ntlm",
  "username": "user",
  "password": "pass",
  "domain": "CORP"
}

CVSS 3.1 auto-scoring

Tous les findings exportés (JSON, SARIF, HTML) sont enrichis d'un score CVSS 3.1 :

{
  "name": "SQL Injection",
  "severity": "high",
  "cvss_score": 8.8,
  "cvss_vector": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:L"
}

Vecteurs pré-définis pour 18 catégories : SQLi, XSS, SSTI, SSRF, CMDi, LFI, CORS, secrets, CVE…

Mutation Fuzzing

Les templates avec des payloads peuvent utiliser le moteur de mutation pour générer automatiquement des variantes :

from core.template_engine.fuzzing import mutate_payloads

seeds = ["' OR 1=1--", "{{7*7}}"]
mutated = mutate_payloads(seeds, strategies=["case_flip", "double_encode", "null_byte"])

8 stratégies disponibles : case_flip, double_encode, unicode_escape, comment_inject, null_byte, whitespace_alt, repeat, truncate.

Plugin API

Créez des modules scanner externes sans modifier le code source :

# mypackage/scanner.py
class MyScanner:
    key = "my_scanner"

    def __init__(self, target, timeout, extra_headers, safe, rate_limiter, *, proxy=None):
        self.target = target

    async def run(self) -> dict:
        return {"module": self.key, "findings": [], "score": 100, "status": "ok", "summary": ""}

# pyproject.toml
[project.entry-points."sentinel_probe.modules"]
my_scanner = "mypackage.scanner:MyScanner"

python3 main.py -t https://target.com --plugins -y   # charger et exécuter
python3 main.py --list-plugins                        # lister les plugins disponibles

Tests

pip install pytest pytest-asyncio
pytest tests/ -v

Fichier	Tests	Couverture
`tests/test_dsl.py`	25	DSL AST cache, fonctions, sécurité (forbidden nodes)
`tests/test_matcher.py`	22	word, regex, status, size, DSL, binary, match_all
`tests/test_utils.py`	18	compute_score, normalize_url, RateLimiter
`tests/test_cvss.py`	14	CVSS 3.1 base scorer, score_finding, enrichissement
`tests/test_fuzzing.py`	15	Stratégies de mutation, mutate_payloads, max_mutations

Exports

Sentinel-Probe supporte quatre formats d'export cumulables :

Format	Option	Description
HTML	`-o rapport.html`	Rapport interactif avec graphiques (Chart.js)
JSON	`--json rapport.json`	Export structuré pour intégration CI/CD ou SIEM
Markdown	`--md`	Sauvegardé dans `reports/sentinel_<domaine>_<date>.md`
SARIF	`--sarif results.sarif`	SARIF 2.1.0 pour GitHub Code Scanning / GitLab Security

Profils de scan

Profil	Modules activés	Crawl	Timeout
`quick`	Headers, SSL, CORS, Takeover, Dep	—	5s
`standard`	Headers, SSL, CORS, SQLi, XSS, Dirs + Crawl	30 pages	10s
`thorough`	Tous les modules (inclut templates)	100 pages	15s

Mode `--safe`

Le mode --safe désactive tous les modules qui envoient des payloads actifs vers la cible :

SQL Injection, NoSQL Injection
XSS Scanner
SSTI Scanner
LFI / Path Traversal
Open Redirect
Command Injection
Templates avec tags injection ou fuzz
Stress Test

Les modules passifs (Headers, SSL, CORS, Ports, Tech Stack Detection, Subdomain Takeover, Dependency Confusion, templates exposure/misconfig/cve…) continuent de s'exécuter normalement.

Mode `--diff` (CI/CD)

Comparaison de deux rapports JSON pour détecter les régressions :

# Générer deux rapports
python3 main.py -t https://monsite.com --all --json v1.json -y
python3 main.py -t https://monsite.com --all --json v2.json -y

# Comparer
python3 main.py --diff v1.json v2.json
# exit 0 = aucune régression, exit 1 = nouvelles vulnérabilités

Combiné à --exit-code, permet de bloquer un pipeline GitHub Actions / GitLab CI.

Multi-cibles

# urls.txt
# https://site1.com
# https://site2.com
# https://api.monsite.com

python3 main.py --targets urls.txt --all -y

Les lignes commençant par # sont ignorées.
Les exports HTML/JSON sont suffixés par l'index (rapport_1.html, rapport_2.html…).
Exit code 2 si au moins une cible présente des vulnérabilités HIGH/CRITICAL (avec --exit-code).

Authentification

Pour scanner des zones protégées par authentification :

# Cookie de session
python3 main.py -t https://app.monsite.com --all --cookie "session=abc123; csrf=xyz" -y

# Bearer token JWT
python3 main.py -t https://api.monsite.com --vuln --token "eyJhbGciOiJIUzI1NiJ9...." -y

# Les deux combinés
python3 main.py -t https://monsite.com --all --cookie "session=abc" --token "eyJ..." -y

Les en-têtes sont transmis à tous les modules et templates.

Exemple de rapport terminal

[ Tech Stack Detection ]  ℹ  —      nginx/1.24, PHP/8.2, WordPress 6.4
[ Template Engine ]       ⚠  72/100  3 finding(s) — env-file-exposure (CRITICAL), swagger-ui-exposure (MEDIUM)
[ Headers Audit ]        ✅  90/100  CSP, HSTS, X-Frame-Options présents
[ SSL/TLS Audit ]        ✅ 100/100  TLSv1.3, certificat valide
[ CORS Check ]           ✅ 100/100  Aucune misconfiguration
[ SQL Injection ]        ✅ 100/100  Aucune erreur SQL détectée
[ NoSQL Injection ]      ✅ 100/100  Aucune injection MongoDB
[ XSS Scanner ]          ✅ 100/100  Payloads correctement filtrés
[ SSTI Scanner ]         ✅ 100/100  Aucune expression évaluée
[ LFI / Path Traversal ] ✅ 100/100  Aucun fichier sensible accessible
[ Open Redirect ]        ✅ 100/100  Redirections correctement validées
[ Command Injection ]    ✅ 100/100  Aucune sortie OS détectée
[ Dir Enumeration ]      ✅  95/100  0 chemins sensibles exposés
[ Port Scanner ]         ✅  94/100  80/443 ouverts uniquement
[ Vuln Scanner ]         ✅ 100/100  0 critique(s), 0 moyen(s)
[ Stress Test ]          ✅ 100/100  17k req — 34ms moy — 580 RPS
[ Subdomain Takeover ]   ✅ 100/100  Aucun CNAME vers service non revendiqué
[ Dependency Confusion ] ✅ 100/100  Aucun fichier de dépendances exposé

GLOBAL : 95/100 — 1 CRITICAL

Compatibilité

Python 3.10+
macOS, Linux, Windows (WSL recommandé)
Fonctionne sur : sites statiques, Next.js/Vercel, Django, Rails, WordPress, APIs REST

Stacks testées sans faux positifs

Next.js + Vercel : middleware auth (307), CDN 403, CSP dynamique via nonce
Cloudflare : rate limiting (429), WAF
Supabase : CORS, JWT
Sites avec redirect canonique www.

Architecture

Sentinel-Probe/
├── main.py                           # Point d'entrée CLI (click)
├── core/
│   ├── template_engine/
│   │   ├── __init__.py               # Exports publics
│   │   ├── models.py                 # Dataclasses : Template, Matcher, Extractor…
│   │   ├── variables.py              # Résolution {{BaseURL}}, {{Host}}…
│   │   ├── dsl.py                    # Évaluateur DSL sécurisé (sans eval())
│   │   ├── matcher.py                # word, regex, status, size, dsl, binary
│   │   ├── extractor.py              # regex, kval, json, dsl
│   │   ├── loader.py                 # Chargeur YAML avec filtres tags/severity/id
│   │   └── engine.py                 # Moteur async : pool TCP, semaphore, fuzzing
│   ├── banner.py                     # ASCII art + infos
│   ├── charts.py                     # Dashboard terminal (rich)
│   ├── constants.py                  # MODULE_LABELS, VERSION…
│   ├── orchestrator.py               # Coordinateur async des modules
│   ├── reporter.py                   # Exports HTML / JSON / Markdown
│   └── utils.py                      # Utilitaires URL + RateLimiter
├── modules/
│   ├── headers_audit.py              # Audit en-têtes HTTP
│   ├── ssl_audit.py                  # Audit SSL/TLS
│   ├── cors_check.py                 # Check CORS
│   ├── sql_injection.py              # Scanner SQLi
│   ├── nosql_injection.py            # Scanner NoSQL Injection
│   ├── xss_scanner.py                # Scanner XSS
│   ├── ssti_scanner.py               # Scanner SSTI
│   ├── lfi_scanner.py                # Scanner LFI / Path Traversal
│   ├── open_redirect.py              # Scanner Open Redirect
│   ├── cmdi_scanner.py               # Scanner Command Injection
│   ├── dir_enum.py                   # Enumération répertoires
│   ├── port_scanner.py               # Scan de ports
│   ├── vuln_scanner.py               # 20 modules de vulnérabilités
│   ├── stress_test.py                # Test de charge
│   ├── crawler.py                    # Crawler BFS same-origin
│   ├── tech_detect.py                # Fingerprinting passif
│   ├── subdomain_takeover.py         # Détection subdomain takeover
│   ├── dep_confusion.py              # Dependency confusion
│   ├── crlf_scanner.py               # CRLF / Header Injection (v1.1.3)
│   └── graphql_scanner.py            # GraphQL scanner (v1.1.3)
├── templates/
│   ├── exposure/                     # .env, .git, phpinfo, Swagger, GraphQL…
│   ├── misconfig/                    # CORS, clickjacking, directory listing…
│   ├── cve/                          # Log4Shell, Spring Actuator, Laravel…
│   ├── injection/                    # SSTI, SQLi, XSS, open redirect
│   └── takeover/                     # CNAME dangling
├── wordlists/
│   └── common_dirs.txt               # Wordlist (400+ chemins)
├── reports/                          # Rapports générés (HTML, JSON, Markdown)
├── LICENSE
├── README.md
├── CHANGELOG.md
├── pyproject.toml
└── requirements.txt

Avertissement légal

UTILISATION AUTORISÉE UNIQUEMENT

Sentinel-Probe est conçu pour tester des systèmes dont vous êtes propriétaire ou pour lesquels vous disposez d'une autorisation écrite explicite. L'utilisation de cet outil sur des systèmes sans autorisation est illégale dans la plupart des juridictions (notamment en France sous l'article 323-1 du Code Pénal, et aux États-Unis sous le Computer Fraud and Abuse Act).

Les auteurs déclinent toute responsabilité en cas d'utilisation abusive.

Contribuer

Fork du dépôt
Créer une branche : git checkout -b feature/nouveau-module
Commit : git commit -m "feat: ajouter module X"
Push : git push origin feature/nouveau-module
Ouvrir une Pull Request

Les templates YAML sont la façon la plus simple de contribuer — aucune connaissance du code Python n'est nécessaire.

Licence

Distribué sous licence GPL-3.0. Voir LICENSE pour les détails.

Sentinel-Probe 1.1.3 — Développé par @Lydiaix-Code — 13 scanners actifs, moteur de templates YAML, 9 800+ CVE — Licence GPL-3.0 — Changelog

Name		Name	Last commit message	Last commit date
Latest commit History 17 Commits
core		core
modules		modules
tests		tests
wordlists		wordlists
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
README.md		README.md
main.py		main.py
pyproject.toml		pyproject.toml
requirements.txt		requirements.txt

Folders and files

Latest commit

History

Repository files navigation

Sentinel-Probe

⚠️ Avertissement légal — Utilisation autorisée uniquement

Fonctionnalités

Installation

Utilisation

Moteur de templates YAML

Format d'un template

Variables disponibles

Types de matchers

Types d'extracteurs

DSL — 35+ fonctions disponibles

9 800+ templates communautaires

Écrire un template custom

Options

Nouveautés v1.1.3

CRLF / Header Injection Scanner (--crlf)

GraphQL Scanner (--graphql)

Flag --min-confidence (réduction des faux positifs)

Browser Engine — Playwright (--browser)

Auth avancée (--auth-config)

CVSS 3.1 auto-scoring

Mutation Fuzzing

Plugin API

Tests

Exports

Profils de scan

Mode --safe

Mode --diff (CI/CD)

Multi-cibles

Authentification

Exemple de rapport terminal

Compatibilité

Stacks testées sans faux positifs

Architecture

Avertissement légal

Contribuer

Licence

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

CRLF / Header Injection Scanner (`--crlf`)

GraphQL Scanner (`--graphql`)

Flag `--min-confidence` (réduction des faux positifs)

Browser Engine — Playwright (`--browser`)

Auth avancée (`--auth-config`)

Mode `--safe`

Mode `--diff` (CI/CD)

Packages